
import JsonUtils from './jsonUtils';
import Cookie from 'Cookie';
import Base64 from 'Base64';
// 引用Common
import Common from 'Common';
// 引用正则表达式
import Regular from './regexp';
// //预览文档上传队列
// import SendMsg2Queue_I from '../com-Interface/res/sendMsg2Queue';
// //获取文档路径
// import GetResPreviewUrl_I from '../com-Interface/res/getResPreviewUrl';

/**
 * 公共方法
 * @type {{}}
 */
const PublicFn = {
    /**
     * 获取浏览器信息
     */
    getBrowserInfo:()=>{
        let u = navigator.userAgent,
            s = u.toLowerCase(),
            app = navigator.appVersion;

        return {
            IsSafari: s.indexOf("applewebkit") > -1,
            IsOpera: !!window.opera,
            IsAIR: s.indexOf('adobeair') > -1,
            IsMac: s.indexOf('macintosh') > -1,
            isFirefox:navigator.userAgent.indexOf("Firefox")>0,

            trident: u.indexOf('Trident') > -1, //IE内核
            presto: u.indexOf('Presto') > -1, //opera内核
            webKit: u.indexOf('AppleWebKit') > -1, //苹果、谷歌内核
            gecko: u.indexOf('Gecko') > -1 && u.indexOf('KHTML') === -1, //火狐内核
            mobile: !!u.match(/AppleWebKit.*Mobile.*/), //是否为移动终端
            ios: !!u.match(/(i[^;]+;( U;)? CPU.+Mac OS X)/), //ios终端
            android: u.indexOf('Android') > -1 || u.indexOf('Linux') > -1, //android终端或者uc浏览器
            iPhone: u.indexOf('iPhone') > -1 , //是否为iPhone或者QQHD浏览器
            iPad: u.indexOf('iPad') > -1, //是否iPad
            webApp: u.indexOf('Safari') === -1 //是否web应该程序，没有头部与底部
        };
    },
    /**
     * 判断是否为移动端设备访问
     * @returns {boolean}
     */
    isMobileTerminal:()=>{
        let _is = false;
        if( PublicFn.getBrowserInfo().mobile ||
            PublicFn.getBrowserInfo().ios ||
            PublicFn.getBrowserInfo().android ||
            PublicFn.getBrowserInfo().iPhone ||
            PublicFn.getBrowserInfo().iPad
        ){
            _is = true;
        }
        return _is;
    },
    cleanWindow:()=>{
        // 是否重置iframe的高度
        PublicFn.resetThisIframe();
    },
    /**
     * 第一个参数DOM对象是否包含第二个参数DOM对象里
     * @param target：父节点，目标节点
     * @param ele：需要包含的节点
     */
    isContains_dom:(target, ele)=>{
        if(!ele || ele === document) return false;

        return ele === target ? true : PublicFn.isContains_dom(target, ele.parentNode);
    },
    /**
     * 重置浮点数float数值类型；保留小数点规定位数
     * @param _float：浮点数值
     * @param pos：保留小数点后位数
     * @returns {number}
     */
    formatFloat:(_float,pos)=>{
        return Math.round(_float*Math.pow(10, pos))/Math.pow(10, pos);
    },
    /**
     * 制保留2位小数，如：2，会在2后面补上00.即2.00
     * @param x
     * @returns {*}
     */
    toDecimal2:(x)=>{
        let f = parseFloat(x);
        if (isNaN(f)) {
            return false;
        }
        f = Math.round(x*100)/100;
        let s = f.toString();
        let rs = s.indexOf('.');
        if (rs < 0) {
            rs = s.length;
            s += '.';
        }
        while (s.length <= rs + 2) {
            s += '0';
        }
        return s;
    },
    /**
     * 如果当前页面为iframe嵌入形式，重新计算当前iframe的高度，用于自适应
     */
    resetThisIframe:()=>{
        // 判断当前页面是否iframe嵌入
        if(self.frameElement && self.frameElement.tagName === "IFRAME"){
            let _h = document.body.scrollHeight;
            self.parent.setIframeHeight(_h);
        }
    },
    /**
     * 获取6位随机数
     * @returns {number}
     */
    creatRandomNum:()=>{
        let random_num = 0;
        for(let i=0;i<6;i++)
        {
            random_num+=Math.floor(Math.random()*100000);
        }
        return random_num;
    },
    /**
     *  判断传入参数的类型，以字符串的形式返回
     *  @obj：数据
     **/
    dataType:(obj)=>{
        if (obj===null) return "Null";
        if (obj===undefined) return "Undefined";
        return Object.prototype.toString.call(obj).slice(8,-1);
    },
    /**
     * 创建唯一标识
     */
    creatGuid:()=>{
        let _GRandom = (((1+Math.random())*0x10000)|0).toString(16).substring(1),
            _bStr = "";
        for ( let i=0;i<32;i++ ){
            if ( i===2||i===4||i===8||i===16 ){
                _bStr += _GRandom;
            }
        }
        return _bStr;
    },
    /**
     * 处理树形结构数据，通过关联参数字段将有关联关系的数据整合起来，返回父子关系型数据结构；
     *
     * @param data:数据集合，改数据类型为数组，包含对象数据
     * @param pcode:父节点名称，用关联当前对象的父级，字符串类型（例如："parentCode"）
     * @param code:当前对象的节点名称，字符串类型（例如："code"）
     * @param children:关联关系整合后，父级包含子级对象集合的名称，用来存放当前对象的所有子级，字符串类型（例如："children"）
     */
    dealTreeData:(data, pcode, code, children)=>{
        let r = [],tempMap = [];
        if ( PublicFn.dataType(data) === "Array" ){
            for ( let j=0; j<data.length; j++ ){
                if ( tempMap[data[j][pcode]] && data[j][code] != data[j][pcode] ){
                    if( !tempMap[data[j][pcode]][children] ){
                        tempMap[data[j][pcode]][children] = [];
                    }
                    tempMap[data[j][pcode]][children].push(data[j]);
                }else{
                    r.push(data[j]);
                }
            }
        }
        return r;
    },
    /**
     * 替换主题css样式文件；
     */
    setStyleSheet:(textName, tag)=>{
        // 找到head
        let doc_head = document.getElementsByTagName("head")[0],
            replaceURL = "";
        // 找到所有的link标签
        let link_list = document.getElementsByTagName("link");
        if ( link_list ){
            for ( let i=0;i<link_list.length;i++ ){
                // 找到我们需要替换的link，
                if ( link_list[i].getAttribute("tag") === tag ){
                    // // 获取当前路径，并根据"/"截成数组
                    let _arr = link_list[i].getAttribute("href").split("/");
                    // 要替换的css名称赋值
                    _arr[_arr.length-1]=textName+".css";
                    // 重新编译成路径
                    for( let i= 0,len=_arr.length;i<len;i++ ){
                        if( _arr[i] === "" ){
                            replaceURL += "/";
                        }else{
                            replaceURL += _arr[i];
                            if( i!==len-1 ){
                                replaceURL += "/";
                            }
                        }
                    }

                    // 将这个link标签重head中移除
                    doc_head.removeChild(link_list[i]);
                }
            }
            if ( replaceURL!=="" ){
                // 创建一个新link标签
                let link_style = document.createElement("link");
                // 对link标签中的属性赋值
                link_style.setAttribute("rel","stylesheet");
                // link_style.setAttribute("type","text/css");
                link_style.setAttribute("href",replaceURL);
                link_style.setAttribute("tag",tag);
                // 加载到head中最后的位置
                doc_head.appendChild(link_style);
            }
        }
    },
    /**
     * 获取cookie中登录用的信息
     * @returns {*}
     */
    getLoginUserCookies:()=>{
        // 获取person_cookie数据
        let _personCookie = Cookie.get("person_cookie");
        // 判断_personCookie是否存在
        if ( PublicFn.dataType(_personCookie) !== "Undefined" && PublicFn.dataType(_personCookie) !== "Null" ) {
            // 解码
            _personCookie = Base64.decode(_personCookie);
            // 创建json对象类
            let jsonUtils = new JsonUtils();
            // 返回对象
            return jsonUtils.constructor.jsonToMap(_personCookie);
        }
    },
    removeLoginUserCookiesByName:(_name)=>{
        if ( !_name || _name === "" ) return false;
        // 获取所有
        let _personObj = PublicFn.getLoginUserCookies();
        // 判断是否存在
        if ( _personObj && _personObj.person_list.length>0 ){
            // 遍历
            for ( let i=0;i<_personObj.person_list.length;i++ ){
                let _obj = _personObj.person_list[i];
                // 查找
                if ( _obj[i].login_name === _name  ){
                    // 如果匹配到，则删除list列表中的当前用户对象
                    _personObj.person_list.splice(i,1);
                    break;
                }
            }
        }
        // 保存Cookie
        Cookie.set("person_cookie", Base64.encode(JSON.stringify(_personObj)), 30 );
        // 返回删除后用户列表对象
        return _personObj;
    },
    /**
     * 对象数据克隆，完全复制另一份脱离原作用域链
     *
     * @param obj 被复制对象数据
     * @returns
     */
    cloneObj:(obj)=>{
        if ( PublicFn.dataType(obj) !== "Object" ) return obj;
        let newObj = {};
        for ( let key in obj ){
            newObj[key] = PublicFn.cloneObj(obj[key]);
        }
        return newObj;
    },
    /**
     * 原有对象扩展方法，以第一个参数为基准扩展
     * @param o ：扩展对象
     * @param p ：扩展值对象
     * @returns {Object} ： 返回扩展参数对象
     */
    extendedObject:(o,p)=>{
        if ( o === undefined || p === undefined ) return o;
        if ( o === null || p === null ) return o;
        if ( PublicFn.dataType(o) === "Object" && PublicFn.dataType(p) === "Object" ){
            for ( let key in p ){
                o[key] = p[key];
            }
        }
        return o;
    },
    /**
     * 将当前url路径后的参数值处理为对象形式返回
     */
    dealURLParamToObj:()=>{
        let _url = window.location.href;
        let items = _url.split("?");
        let arr , Json = {};
        if ( items.length>1 ){
            items = items[1].split("&");
            for(let i=0;i<items.length;i++){
                arr = items[i].split("=");
                Json[arr[0]]=arr[1];
            }

        }
        return Json;
    },
    /**
     * 重置URL对应的参数值，如果参数不存在，_key不存在，则新增加
     * @param _key：参数key值
     * @param _value：参数value值
     */
    repeatURLParam:(_key, _value)=>{
        // 获取url参数对象
        let _urlPram = PublicFn.dealURLParamToObj();
        // 判断是否存在
        if ( _urlPram ) {
            // 将参数_key添加至_urlPram中，如果_key在_urlPram中存在则覆盖
            _urlPram[_key] = _value;
        }
        // 处理_urlPram，将_urlPram对象中的参数值拼接为url参数形式
        let _json = [];
        if ( _urlPram ){
            for ( let k in _urlPram ){
                _json.push(k + "=" + _urlPram[k]);
            }
        }
        let _newUrl = window.location.href;
        if ( _json.length>0 ){
            _newUrl  = _newUrl.split("?")[0] + "?" + _json.join("&");
        }
        // 重置url
        history.replaceState(null,null,_newUrl)
    },
    /**
     * 重置url的路由功能，根据_routerObj路由对象来判断配置路由相关功能
     * @param _routerObj：路由菜单对象
     * @param _pageId：配置value值
     */
    repeatURLRouter:(_routerObj, _pageId)=>{
        // 判断_routerObj是否为对象参数
        if (PublicFn.dataType(_routerObj) !== "Object") return false;
        // 判断路由开关是否开启
        if ( _routerObj.isOpen ){
            // 路由开启。重置当前路由参数对象
            PublicFn.repeatURLParam( _routerObj.menuID, _pageId );
        }
    },
    /**
     * 根据相应的参数对象，清空相对应的路由参数
     * @param _routerObj：路由菜单对象
     */
    emptyURLRouterByObj:(_routerObj)=>{
        // 判断_routerObj是否为对象参数
        if (PublicFn.dataType(_routerObj) !== "Object") return false;
        // 获取url参数对象
        let _urlPram = PublicFn.dealURLParamToObj();
        // 判断是否存在
        if ( _urlPram ) {
            // 删除相对应的属性
            delete _urlPram[_routerObj.menuID];
        }
        // 处理_urlPram，将_urlPram对象中的参数值拼接为url参数形式
        let _json = [];
        if ( _urlPram ){
            for ( let k in _urlPram ){
                _json.push(k + "=" + _urlPram[k]);
            }
        }
        let _newUrl = window.location.href;
        if ( _json.length>0 ){
            _newUrl  = _newUrl.split("?")[0] + "?" + _json.join("&");
        }
        // 重置url
        history.replaceState(null,null,_newUrl);
    },
    /**
     * 根据相应的key值获取路由中的page信息
     * @param _routerObj：当前路由对象
     */
    getURLRouter:( _routerObj )=>{
        let _page = null;
        // 判断_routerObj是否为对象参数
        if (PublicFn.dataType(_routerObj) !== "Object") return false;
        // 判断路由开关是否开启
        if ( _routerObj.isOpen ){
            // 路由开启。获取相应的参数
            _page = PublicFn.dealURLParamToObj()[_routerObj.menuID];
        }
        return _page;
    },
    getContextHtmlPath:()=>{
        let pathName = document.location.pathname;
        let index = pathName.substr(1).indexOf("/");
        let result = pathName.substr(0,index+1);
        if( result != "/dsideal_yy" ) {
            result = pathName.substr(0,0);
        }
        return result;
    },
    /**
     * 获取action路径信息
     * @returns {string}
     */
    getContextActionPath:()=>{
        let pathName = document.location.pathname;

        let index = pathName.substr(1).indexOf("/html");
        let result = pathName.substr(0,index+1);

        result = "/dsideal_yy";
        return result;
    },
    /**
     * 获取host路径
     */
    getServerUrl:()=>{
        let server_url = document.location.host,
            _action_path = "";
        if( server_url.substring(0,7) !== "http://" ){
            _action_path = "http://" + server_url;
        }else{
            _action_path = server_url;
        }
        return _action_path;
    },
    /**
     * 自url地址后面获取需要的参数值
     * @param name
     * @returns {null}
     */
    getQueryString:(name)=>{
        let reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)", "i");
        let r = window.location.search.substr(1).match(reg);
        if (r !== null)
            return unescape(r[2]);
        return null;
    },
    /**
     * 预览文档
     * @param fileId:资源的fileid
     * @param extension资源的扩展名
     * @param resourceIdInt:资源的intId
     * @param _fn:回调函数
     */
    previewDocument:(fileId,extension,resourceIdInt,_fn)=>{
        let result = "/dsideal_yy";

        let _url = result + "/common/sendMsg2Queue";
        let content = {"file_id":fileId,"ext":extension}
        content = JSON.stringify(content);

        let _param = {
            "queue":"ResOffice",//队列名称
            "content":content,//写入的消息内容
        }

        PublicFn.geturlCount = 0;
        // 创建common实体类
        let _common = new Common(_url, _param);
        // 调用
        _common.PostRequest().then(data => {
            if (data) {
                // // 保存数据
                // this.setResponseData(data, _saveKey);
                if (data && data.success){
                    PublicFn.getPreviewUrl(fileId,resourceIdInt,_fn);
                }
            }
        });
    },
    geturlCount:0,
    /**
     * 获取预览文档的url
     * @param fileId:资源的fileid
     * @param resourceIdInt:资源的intId
     * @param _fn:回调函数
     */
    getPreviewUrl:(fileId,resourceIdInt,_fn)=>{
        let result = "/dsideal_yy";

        let _url = result + "/resCtl/getResPreviewUrl";
        let _param = {
            "fileId":fileId,//fileid
            "resourceIdInt":resourceIdInt,//资源id
        }
        // 创建common实体类
        let _common = new Common(_url, _param);
        // 调用
        _common.GetRequest().then(data => {
            PublicFn.geturlCount = PublicFn.geturlCount+1;
            if (data) {
                // 保存数据
                // this.setResponseData(data, _saveKey);
                // 回调函数
                if (data){
                    if (data.success && data.result && data.result.state){
                        _fn && _fn(data);
                    }else{
                        if (PublicFn.geturlCount > 500){
                            PublicFn.geturlCount = 0;
                        }else{
                            setTimeout(()=>{
                                PublicFn.getPreviewUrl(fileId,resourceIdInt,_fn);
                            },1);
                        }
                    }
                }
            }
        });
    },

    /**
     * 检测资源是否为支持的视频格式
     * @param str:资源文件后缀名
     * @returns {boolean}
     */
    checkVideoFormat:(str)=>{
        switch(str){
            case "avi":
            case "mp4":
            case "mpg":
            case "mpeg":
            case "wmv":
            case "asf":
            case "flv":
            case "rmvb":
            case "mov":
                return true;
            default:
                return false;
        }
    }
};

export default PublicFn;